// 引入全局数据和工具
const app = getApp();
const globalData = require('../../common/globalData');
const utils = require('../../common/utils');

Page({
    data: {
        taskConfig: globalData.taskConfig, // 任务配置（类型/难度/状态选项）
        currentFilter: {                   // 当前筛选条件
            type: '',                       // 类型（空=全部）
            difficulty: '',                 // 难度（空=全部）
            status: '全部状态',             // 状态（默认全部）
            typeIndex: 0,                   // 类型选择器索引
            difficultyIndex: 0,             // 难度选择器索引
            statusIndex: 0                  // 状态选择器索引
        },
        filteredTasks: [],                 // 筛选后的任务列表
        showTaskModal: false,              // 任务弹窗显示状态
        isEditing: false,                  // 是否编辑模式
        formData: {                        // 表单数据
            taskId: '',
            name: '',
            desc: '',
            difficulty: '',
            difficultyIndex: 0,
            points: '',
            type: '',
            typeIndex: 0
        }
    },

    // 页面加载时初始化
    onLoad() {
        // 初始化筛选任务
        this.filterTasks();

        // 同步自定义TabBar选中态（任务管理是索引1）
        if (typeof this.getTabBar === 'function' && this.getTabBar()) {
            this.getTabBar().setData({ current: 1 });
        }
    },

    // 页面显示时刷新（确保从其他页回来后数据最新）
    onShow() {
        this.filterTasks();
    },

    // ---------------------- 筛选功能 ----------------------
    // 类型筛选变更
    onTypeChange(e) {
        const index = e.detail.value;
        const type = globalData.taskConfig.typeOptions[index];
        this.setData({
            'currentFilter.type': type,
            'currentFilter.typeIndex': index
        }, () => {
            this.filterTasks();
        });
    },

    // 难度筛选变更
    onDifficultyChange(e) {
        const index = e.detail.value;
        const difficulty = globalData.taskConfig.difficultyOptions[index];
        this.setData({
            'currentFilter.difficulty': difficulty,
            'currentFilter.difficultyIndex': index
        }, () => {
            this.filterTasks();
        });
    },

    // 状态筛选变更
    onStatusChange(e) {
        const index = e.detail.value;
        const status = globalData.taskConfig.statusOptions[index];
        this.setData({
            'currentFilter.status': status,
            'currentFilter.statusIndex': index
        }, () => {
            this.filterTasks();
        });
    },

    // 筛选任务核心逻辑
    filterTasks() {
        const { taskList } = globalData;
        const { type, difficulty, status } = this.data.currentFilter;
        let filtered = [...taskList];

        // 1. 类型筛选（非空才筛选）
        if (type) {
            filtered = filtered.filter(task => task.type === type);
        }

        // 2. 难度筛选（非空才筛选）
        if (difficulty) {
            filtered = filtered.filter(task => task.difficulty === difficulty);
        }

        // 3. 状态筛选（排除“全部状态”）
        if (status !== '全部状态') {
            filtered = filtered.filter(task => task.status === status);
        }

        // 更新筛选后列表
        this.setData({ filteredTasks: filtered });
    },

    // ---------------------- 任务表单（创建/编辑） ----------------------
    // 打开创建任务弹窗
    openCreateTaskModal() {
        this.setData({
            showTaskModal: true,
            isEditing: false,
            formData: {
                taskId: '',
                name: '',
                desc: '',
                difficulty: '',
                difficultyIndex: 0,
                points: '',
                type: '',
                typeIndex: 0
            }
        });
    },

    // 打开编辑任务弹窗
    handleEditTask(e) {
        // 注意：传递对象需用JSON.stringify，接收时JSON.parse
        const task = JSON.parse(e.currentTarget.dataset.task);
        // 计算选择器索引
        const difficultyIndex = globalData.taskConfig.difficultyOptions.findIndex(
            item => item === task.difficulty
        );
        const typeIndex = globalData.taskConfig.typeOptions.findIndex(
            item => item === task.type
        );

        this.setData({
            showTaskModal: true,
            isEditing: true,
            formData: {
                taskId: task.taskId,
                name: task.name,
                desc: task.desc || '',
                difficulty: task.difficulty,
                difficultyIndex: difficultyIndex >= 0 ? difficultyIndex : 0,
                points: task.points.toString(), // 输入框是字符串类型
                type: task.type || '',
                typeIndex: typeIndex >= 0 ? typeIndex : 0
            }
        });
    },

    // 关闭任务弹窗
    closeTaskModal() {
        this.setData({ showTaskModal: false });
    },

    // 阻止弹窗冒泡（点击弹窗内容不关闭）
    stopPropagation() {},

    // 表单输入变更
    onFormInput(e) {
        const { key } = e.currentTarget.dataset;
        const { value } = e.detail;
        this.setData({ [`formData.${key}`]: value });
    },

    // 表单选择器变更（难度/类型）
    onFormPickerChange(e) {
        const { key } = e.currentTarget.dataset;
        const index = e.detail.value;
        const options = key === 'difficulty'
            ? globalData.taskConfig.difficultyOptions
            : globalData.taskConfig.typeOptions;
        const value = options[index];

        this.setData({
            [`formData.${key}`]: value,
            [`formData.${key}Index`]: index
        });
    },

    // 提交任务表单（创建/编辑通用）
    submitTaskForm() {
        const { formData, isEditing } = this.data;
        const { taskList } = globalData;

        // 1. 表单验证（复用公共工具）
        const validateResult = utils.validateTaskForm(formData);
        if (!validateResult.valid) {
            wx.showToast({ title: validateResult.msg, icon: 'none' });
            return;
        }

        // 2. 处理任务数据
        const newTask = {
            taskId: isEditing ? formData.taskId : `task_${Date.now()}`,
            name: formData.name.trim(),
            desc: formData.desc.trim(),
            difficulty: formData.difficulty,
            points: Number(formData.points),
            type: formData.type || '未分类',
            status: isEditing
                ? taskList.find(t => t.taskId === formData.taskId).status // 编辑时保留原状态
                : '待办' // 新建任务默认待办
        };

        // 3. 更新全局任务列表
        let newTaskList;
        if (isEditing) {
            // 编辑模式：替换原有任务
            newTaskList = taskList.map(task =>
                task.taskId === formData.taskId ? newTask : task
            );
            wx.showToast({ title: '任务修改成功' });
        } else {
            // 创建模式：新增任务
            newTaskList = [newTask, ...taskList]; // 新增任务放最前面
            wx.showToast({ title: '任务创建成功' });
        }
        globalData.taskList = newTaskList;

        // 4. 关闭弹窗并刷新筛选列表
        this.setData({ showTaskModal: false }, () => {
            this.filterTasks();
        });
    },

    // ---------------------- 任务删除/状态切换 ----------------------
    // 删除任务（带确认弹窗）
    handleDeleteTask(e) {
        const taskId = e.currentTarget.dataset.taskid;
        const { taskList } = globalData;

        wx.showModal({
            title: '确认删除',
            content: '此任务将被永久删除，是否继续？',
            confirmColor: '#FF6B6B',
            success: (res) => {
                if (res.confirm) {
                    // 过滤掉要删除的任务
                    const newTaskList = taskList.filter(task => task.taskId !== taskId);
                    globalData.taskList = newTaskList;

                    // 刷新筛选列表
                    this.filterTasks();
                    wx.showToast({ title: '任务已删除' });
                }
            }
        });
    },

    // 切换任务状态（待办 ↔ 已完成）
    handleToggleStatus(e) {
        const taskId = e.currentTarget.dataset.taskid;
        const { taskList } = globalData;

        // 找到任务并切换状态
        const newTaskList = taskList.map(task => {
            if (task.taskId === taskId) {
                return { ...task, status: task.status === '待办' ? '已完成' : '待办' };
            }
            return task;
        });

        // 更新全局数据并刷新筛选列表
        globalData.taskList = newTaskList;
        this.filterTasks();
    },

    // ---------------------- 辅助方法 ----------------------
    // 获取难度对应的样式类
    getDifficultyClass(difficulty) {
        switch (difficulty) {
            case '简单':
                return 'tm-difficulty-easy';
            case '中等':
                return 'tm-difficulty-medium';
            case '困难':
                return 'tm-difficulty-hard';
            default:
                return '';
        }
    }
});